package com.demo.common.utils;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.demo.config.cache.ObjectCacheConfig;
import com.demo.modules.sys.entity.*;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;

/**
 * 缓存工具类
 *
 * @author Zsx
 * @date 2019年7月24日
 */
@Slf4j
public class CacheUtils {

    /**
     * 获取用户缓存
     *
     * @param userId 用户id
     * @return 用户实体
     */
    public static SysUserEntity getUserCache(Long userId) {
        SysUserEntity user = null;
        try {
            if (userId != null) {
                user = ObjectCacheConfig.userCache.get(userId);
            }
        } catch (Exception e) {
            log.debug("获取用户缓存出错：缓存对象不存在", e);
        }

        return user == null ? new SysUserEntity() : user;
    }

    /**
     * 获取组织缓存
     *
     * @param orgId 组织id
     * @return 组织实体
     */
    public static SysOrgEntity getOrgCache(Long orgId) {
        SysOrgEntity org = null;
        try {
            if (orgId != null) {
                org = ObjectCacheConfig.orgCache.get(orgId);
            }
        } catch (Exception e) {
            log.debug("获取组织缓存出错：缓存对象不存在", e);
        }

        return org == null ? new SysOrgEntity() : org;
    }

    /**
     * 获取菜单缓存
     *
     * @param menuId 菜单id
     * @return 菜单实体
     */
    public static SysMenuEntity getMenuCache(Long menuId) {
        SysMenuEntity menu = null;
        try {
            if (menuId != null) {
                menu = ObjectCacheConfig.menuCache.get(menuId);
            }
        } catch (Exception e) {
            log.debug("获取菜单缓存出错：缓存对象不存在", e);
        }

        return menu == null ? new SysMenuEntity() : menu;
    }

    /**
     * 获取配置管理
     *
     * @param key 配置key
     * @return 配置管理实体
     */
    public static SysConfigEntity getConfCache(String key) {
        SysConfigEntity conf = null;
        try {
            if (key != null) {
                conf = ObjectCacheConfig.confCache.get(key);
            }
        } catch (Exception e) {
            log.debug("获取配置缓存出错：缓存对象不存在", e);
        }

        return conf == null ? new SysConfigEntity() : conf;
    }

    /**
     * 获取字典缓存
     *
     * @param dictId 字典id
     * @return 字典实体
     */
    public static SysDictEntity getDictCache(Long dictId) {
        SysDictEntity dict = null;
        try {
            if (dictId != null) {
                dict = ObjectCacheConfig.dictCache.get(dictId);
            }
        } catch (Exception e) {
            log.debug("获取字典类别缓存出错：缓存对象不存在", e);
        }

        return dict == null ? new SysDictEntity() : dict;
    }

    /**
     * 获取字典内容缓存
     *
     * @param dictValId 字典内容id
     * @return 字典内容实体
     */
    public static SysDictValEntity getDictValCache(Long dictValId) {
        SysDictValEntity dictVal = null;
        try {
            if (dictValId != null) {
                dictVal = ObjectCacheConfig.dictValCache.get(dictValId);
            }
        } catch (Exception e) {
            log.debug("获取字典内容缓存出错：缓存对象不存在", e);
        }

        return dictVal == null ? new SysDictValEntity() : dictVal;
    }

    /**
     * 根据字典编码获取字典内容列表
     *
     * @param dictCode 字典编码
     * @return 字典内容列表
     */
    public static List<SysDictValEntity> getDictValList(String dictCode) {
        SysDictEntity dict = null;
        List<SysDictValEntity> dictValList = new ArrayList<>();

        if (StrUtil.isBlank(dictCode)) {
            return dictValList;
        }

        for (SysDictEntity dictItem : ObjectCacheConfig.dictCache) {
            if (dictItem.getDictCode().equals(dictCode)) {
                dict = dictItem;
                break;
            }
        }
        if (ObjectUtil.isEmpty(dict)) {
            return dictValList;
        }

        final SysDictEntity dictFinal = dict;
        ObjectCacheConfig.dictValCache.forEach(dictVal -> {
            if (dictVal.getDictId().equals(dictFinal.getId())) {
                dictValList.add(dictVal);
            }
        });

        return dictValList;
    }

    /**
     * 根据字典编码、字典内容编码 获取字典内容
     *
     * @param dictCode    字典编码
     * @param dictValCode 字典内容编码
     * @return 字典内容
     */
    public static SysDictValEntity getDictVal(String dictCode, String dictValCode) {
        for (SysDictValEntity dictVal : getDictValList(dictCode)) {
            if (dictVal.getValCode().equals(dictValCode)) {
                return dictVal;
            }
        }

        return new SysDictValEntity();
    }

}
